﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Globalization;

namespace ZYO
{
    public class ZYOShared
    {
        public static Persistence.Obj.e五行生克关系 Check五行生克(Persistence.Obj.enum五行 wx1, Persistence.Obj.enum五行 wx2)
        {
            int ret = wx1 - wx2;
            if (ret < 0)
                ret = ret + 5; // the sum number is 5
            return (Persistence.Obj.e五行生克关系)ret;
        }

        public static bool Is三合(Persistence.Obj.enum地支 dz1, Persistence.Obj.enum地支 dz2, Persistence.Obj.enum地支 dz3)//三合
        {
            if (dz3 == dz1 || dz3 == dz2 || dz1 == dz2) // the same DZ
            {
                return false;
            }
            int i, ii, iii;
            i = (int)dz3 - (int)dz1;
            ii = (int)dz3 - (int)dz2;
            iii = (int)dz1 - (int)dz2;

            i = i % 4;
            ii = ii % 4;
            iii = iii % 4;

            return ((i == 0) & (ii == 0) & (iii == 0));
        }


        public static bool Is合(Persistence.Obj.enum地支 地支1, Persistence.Obj.enum地支 地支2)
        {

            int i = (int)地支1 + (int)地支2;
            i = i % 12;

            return (i == 3);
        }

        public static bool Is冲(Persistence.Obj.enum地支 地支1, Persistence.Obj.enum地支 地支2)
        {
            int i = Math.Abs((int)地支1 - (int)地支2);
            return (i == 6);
        }

        //寅刑巳、巳刑申、子刑卯、卯刑午、丑戌相刑、未辰相刑。又云：辰午酉亥谓之自刑
        public static bool Is刑(Persistence.Obj.enum地支 地支1, Persistence.Obj.enum地支 地支2)
        {
            return false;
        }

        public static Persistence.Obj.e地支冲合关系 Check地支关系(Persistence.Obj.enum地支 地支1, Persistence.Obj.enum地支 地支2)
        {

            Persistence.Obj.e地支冲合关系 chonghe = Persistence.Obj.e地支冲合关系.未知;

            if (Is冲(地支1, 地支2))
            {
                chonghe = Persistence.Obj.e地支冲合关系.冲;
            }
            else if (Is合(地支1, 地支2))
            {
                chonghe = Persistence.Obj.e地支冲合关系.合;
            }
            else if (Is刑(地支1, 地支2))
            {
                chonghe = Persistence.Obj.e地支冲合关系.刑;
            }

            return chonghe;
        }

        //进神 亥化子 寅化卯 巳化午 申化酉 丑化辰 辰化未 未化戌
        //退神 子化亥 卯化寅 午化巳 酉化申 辰化丑 未化辰 戌化未
        public static Persistence.Obj.e动化进退 Check进退(Persistence.Obj.enum地支 e地支From, Persistence.Obj.enum地支 e地支To)
        {
            Persistence.Obj.地支 地支From = new Runtime地支(e地支From).Xml;
            Persistence.Obj.地支 地支To = new Runtime地支(e地支To).Xml;

            Persistence.Obj.e动化进退 jintui = Persistence.Obj.e动化进退.未知;
            if (地支From.五行属性de枚举值 == 地支To.五行属性de枚举值 && 地支From != 地支To)
            {
                int unit = 1;
                //土 进退单位为3; 其他进退单位为1
                if (地支From.五行属性de枚举值 == Persistence.Obj.enum五行.土)
                {
                    unit = 3;
                }

                if (((int)地支To.枚举值 - (int)地支From.枚举值) == unit)
                {
                    jintui = Persistence.Obj.e动化进退.进神;
                }
                else if (((int)地支To.枚举值 - (int)地支From.枚举值) == -1 * unit)
                {
                    jintui = Persistence.Obj.e动化进退.退神;
                }
            }
            return jintui;
        }

        public static EnumType ID2Enum<EnumType>(int id)
        {
            int 基数 = 0;

            if (typeof(EnumType) == typeof(Persistence.Obj.enum天干))
            {
                基数 = int.Parse(Resources.DefaultValues.天干基数);
            }
            if (typeof(EnumType) == typeof(Persistence.Obj.enum地支))
            {
                基数 = int.Parse(Resources.DefaultValues.地支基数);
            }
            if (typeof(EnumType) == typeof(Persistence.Obj.enum甲子))
            {
                基数 = int.Parse(Resources.DefaultValues.甲子基数);
            }
            if (typeof(EnumType) == typeof(Persistence.Obj.enum五行))
            {
                基数 = int.Parse(Resources.DefaultValues.五行基数);
            }
            if (typeof(EnumType) == typeof(Persistence.Obj.enum八卦ID))
            {
                基数 = int.Parse(Resources.DefaultValues.八卦基数);
            }
            if (typeof(EnumType) == typeof(Persistence.Obj.enum节气))
            {
                基数 = int.Parse(Resources.DefaultValues.节气基数);
            }
            if (typeof(EnumType) == typeof(Persistence.Obj.enum六十四卦ID))
            {
                基数 = int.Parse(Resources.DefaultValues.六十四卦基数);
            }

            if (id < 0)
            {
                id = id + Math.Abs(id) * 基数;
            }

            id = id % 基数;

            return (EnumType)Enum.Parse(typeof(EnumType), ID2Name(id, typeof(EnumType)));
        }

        public static EnumType Str2Enum<EnumType>(String name)
        {
            return (EnumType)Enum.Parse(typeof(EnumType), name);
        }

        //根据枚举类型。 通过 Name， 获取ID
        internal int Name2ID(String sName, Type EnumType)
        {
            int i = int.Parse(Resources.DefaultValues.InvalidID);
            if (EnumType != null)
            {
                i = (int)Enum.Parse(EnumType, sName, true);
            }
            return i;
        }

        public static String ID2Name(int iID, Type EnumType)
        {
            String retName = String.Empty;

            if (EnumType == typeof(Persistence.Obj.enum天干))
            {
                retName = ((Persistence.Obj.enum天干)iID).ToString();
            }
            if (EnumType == typeof(Persistence.Obj.enum地支))
            {
                retName = ((Persistence.Obj.enum地支)iID).ToString();
            }
            if (EnumType == typeof(Persistence.Obj.enum甲子))
            {
                retName = ((Persistence.Obj.enum甲子)iID).ToString();
            }
            if (EnumType == typeof(Persistence.Obj.enum五行))
            {
                retName = ((Persistence.Obj.enum五行)iID).ToString();
            }
            if (EnumType == typeof(Persistence.Obj.enum八卦ID))
            {
                retName = ((Persistence.Obj.enum八卦ID)iID).ToString();
            }
            if (EnumType == typeof(Persistence.Obj.enum节气))
            {
                retName = ((Persistence.Obj.enum节气)iID).ToString();
            }
            if (EnumType == typeof(Persistence.Obj.enum六十四卦ID))
            {
                retName = ((Persistence.Obj.enum六十四卦ID)iID).ToString();
            }

            return retName;
        }

        public static bool Is阴阳(int id)
        {
            return (id % 2 == 1);
        }

        //public T GetValue<T>(string value)
        //{
        //    return (T)Convert.ChangeType(value, typeof(T), CultureInfo.InvariantCulture);
        //}
    }

    public class ZYObject : Object
    {
        public Type EnumType;
        public Type PersistenceType;
        public int ID;

        public ZYObject()
        {
            this.ID = int.Parse(Resources.DefaultValues.InvalidID);
        }

        public ZYObject(int id) // call child constructor
        {
        }

        public bool IsValid()
        {
            return (this.ID != int.Parse(Resources.DefaultValues.InvalidID));
        }

        public virtual void AssignProperties()
        {

        }

        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        public static int operator -(ZYObject zy1, ZYObject zy2)
        {
            int delta = zy1.ID - zy2.ID;
            return delta;
        }

        public static ZYObject operator -(ZYObject zy1, int delta)
        {
            int newId = zy1.ID - delta;
            return new ZYObject(newId);
        }

        public static ZYObject operator --(ZYObject zy)
        {
            return (zy - 1);
        }

        public static ZYObject operator +(ZYObject zy1, int delta)
        {
            int newId = zy1.ID + delta;
            return new ZYObject(newId);
        }
        public static ZYObject operator ++(ZYObject zy)
        {
            return zy + 1;
        }

        // override % operator
        public static int mod(int number, int basenumber)
        {
            int modresult = number % basenumber;

            while (modresult < 0)
            {
                modresult = modresult + basenumber;
            }
            if (0 == modresult)
            {
                modresult = basenumber;
            }

            return modresult;
        }

        //Logical Operator
        public static bool operator ==(ZYObject zy1, ZYObject zy2)
        {
            // If both are null, or both are same instance, return true.
            if (System.Object.ReferenceEquals(zy1, zy2))
            {
                return true;
            }

            // If one is null, but not both, return false.
            if (((object)zy1 == null) || ((object)zy2 == null))
            {
                return false;
            }

            return false;
        }

        public static bool operator !=(ZYObject zy1, ZYObject zy2)
        {
            return !(zy1 == zy2);
        }
        public static bool operator >(ZYObject zy1, ZYObject zy2)
        {
            // If both are null, or both are same instance, return true.
            if (System.Object.ReferenceEquals(zy1, zy2))
            {
                return true;
            }

            // If one is null, but not both, return false.
            if (((object)zy1 == null) || ((object)zy2 == null))
            {
                return false;
            }

            return (zy1.ID > zy2.ID);
        }
        public static bool operator <(ZYObject zy1, ZYObject zy2)
        {
            // If both are null, or both are same instance, return true.
            if (System.Object.ReferenceEquals(zy1, zy2))
            {
                return true;
            }

            // If one is null, but not both, return false.
            if (((object)zy1 == null) || ((object)zy2 == null))
            {
                return false;
            }

            return (zy1.ID < zy2.ID);
        }
        public static bool operator >=(ZYObject zy1, ZYObject zy2)
        {
            return !(zy1 < zy2);
        }
        public static bool operator <=(ZYObject zy1, ZYObject zy2)
        {
            return !(zy1 > zy2);
        }

    }

    //public enum e天干
    //{
    //    癸 = 0, 甲, 乙, 丙, 丁, 戊, 己, 庚, 辛, 壬
    //}

    //public enum e地支
    //{
    //    亥 = 0, 子, 丑, 寅, 卯, 辰, 巳, 午, 未, 申, 酉, 戌
    //}

    //public enum e五行
    //{
    //    水 = 0, 木, 火, 土, 金
    //}
    //public enum e甲子
    //{
    //    癸亥 = 0,
    //    甲子, 乙丑, 丙寅, 丁卯, 戊辰, 己巳, 庚午, 辛未, 壬申, 癸酉,
    //    甲戌, 乙亥, 丙子, 丁丑, 戊寅, 己卯, 庚辰, 辛巳, 壬午, 癸未,
    //    甲申, 乙酉, 丙戌, 丁亥, 戊子, 己丑, 庚寅, 辛卯, 壬辰, 癸巳,
    //    甲午, 乙未, 丙申, 丁酉, 戊戌, 己亥, 庚子, 辛丑, 壬寅, 癸卯,
    //    甲辰, 乙巳, 丙午, 丁未, 戊申, 己酉, 庚戌, 辛亥, 壬子, 癸丑,
    //    甲寅, 乙卯, 丙辰, 丁巳, 戊午, 己未, 庚申, 辛酉, 壬戌
    //}

    //public enum e节气
    //{
    //    小寒 = 0, 大寒, 立春, 雨水, 惊蛰, 春分, 清明, 谷雨, 立夏, 小满, 芒种, 夏至, 小暑, 大暑, 立秋, 处暑, 白露, 秋分, 寒露, 霜降, 立冬, 小雪, 大雪, 冬至
    //}
    //public enum e八卦ID
    //{
    //    坤 = 0, 震, 坎, 兑, 艮, 离, 巽, 乾
    //}

    //public enum e六十四卦ID
    //{
    //    坤为地 = 0, 地雷复, 地水师, 地泽临, 地山谦, 地火明夷, 地风升, 地天泰,
    //    雷地豫, 震为雷, 雷水解, 雷泽归妹, 雷山小过, 雷火丰, 雷风恒, 雷天大壮,
    //    水地比, 水雷屯, 坎为水, 水泽节, 水山蹇, 水火既济, 水风井, 水天需,
    //    泽地萃, 泽雷随, 泽水困, 兑为泽, 泽山咸, 泽火革, 泽风大过, 泽天诀,
    //    山地剥, 山雷颐, 山水蒙, 山泽损, 艮为山, 山火贲, 山风蛊, 山天大畜,
    //    火地晋, 火雷噬嗑, 火水未济, 火泽睽, 火山旅, 离为火, 火风鼎, 火天大有,
    //    风地观, 风雷益, 风水涣, 风泽中孚, 风山渐, 风火家人, 巽为风, 风天小畜,
    //    天地否, 天雷无妄, 天水讼, 天泽履, 天山遁, 天火同人, 天风后, 乾为天
    //}

    //public enum e六十四卦by数
    //{
    //    乾为天 = 1, 坤为地, 水雷屯, 山水蒙, 水天需, 天水讼, 地水师, 水地比, 
    //    风天小畜, 天泽履, 天地否, 地天泰, 天火同人, 火天大有, 地山谦, 雷地豫,
    //    泽雷随, 山风蛊, 地泽临, 风地观, 火雷噬嗑, 山火贲, 山地剥, 地雷复, 
    //    天雷无妄, 山天大畜, 山雷颐, 泽风大过, 坎为水, 离为火, 泽山咸, 雷风恒, 
    //    天山遁, 雷天大壮, 火地晋, 地火明夷, 风火家人, 火泽睽, 水山蹇, 雷水解, 
    //    山泽损, 风雷益, 泽天诀, 天风后, 泽地萃, 地风升, 泽水困, 水风井, 
    //    泽火革, 火风鼎, 震为雷, 艮为山, 风山渐, 雷泽归妹, 雷火丰, 火山旅, 
    //    巽为风, 兑为泽, 风水涣, 水泽节, 风泽中孚, 雷山小过, 水火既济, 火水未济
    //}

    //public class ZYOEnum
    //{
    //    public enum e地支冲合关系
    //    {
    //        未知,
    //        冲,
    //        合,
    //        刑
    //    }

    //    public struct sturct地支关系
    //    {
    //        public e五行生克关系 生克;
    //        public e地支冲合关系 冲合;

    //    }

    //    public enum e动化进退
    //    {
    //        未知,
    //        进神,
    //        退神
    //    }

    //    public enum e生旺库绝
    //    {
    //        未知,
    //        长生,
    //        旺,
    //        墓,
    //        绝
    //    }

    //    public struct struct动爻变化
    //    {
    //        public e动化进退 进退;
    //        public e生旺库绝 生旺库绝;
    //        public sturct地支关系 地支关系;
    //    }

    //    public enum e月建旺相
    //    {
    //        未知,
    //        月破,
    //        休囚,
    //        余气,
    //        相,
    //        次旺,
    //        旺
    //    }

    //    public enum e爻之旺相
    //    {
    //        平,
    //        旺,
    //        衰
    //    }
    //    public enum e有用无用
    //    {
    //        未知,
    //        有用,
    //        无用
    //    }

    //public enum e八字六神
    //{
    //    日主,
    //    偏印,
    //    印授,
    //    煞,
    //    正官,
    //    食神,
    //    伤官,
    //    偏财,
    //    正财,
    //    比肩,
    //    劫财
    //}

    //public enum e六神
    //{
    //    兄弟 = 0, 子孙, 妻财, 官鬼, 父母
    //}

    //public enum e先天八卦
    //{
    //    乾 = 1, 兑, 离, 震, 巽, 坎, 艮, 坤
    //}

    //public enum e元
    //{
    //    上元 = 0,
    //    中元,
    //    下元
    //}
    // public enum e起卦方法
    //{
    //    摇卦,
    //    时间,
    //    测字,
    //    数字
    //} 

    //public enum e求问
    //{
    //    未知,
    //    求财,
    //    婚姻男,
    //    文凭,
    //    子女,
    //    朋友,
    //    婚姻女,
    //    事业,
    //    疾病,
    //    股票
    //}
    //}

}
